server/mcp/prompts/admin/review-agent-chats.ts-22-22 (1)

22-22: 🎯 Functional Correctness | 🟡 Minor

Chat link path is inconsistent with the actual application routes.

The prompt in server/mcp/prompts/admin/review-agent-chats.ts instructs reports to link to https://nuxt.com/admin/agent/<chat-id>. However, the application only defines the chat route at layers/nuxi/app/pages/dashboard/chat/[id].vue, which corresponds to https://nuxt.com/dashboard/chat/<id>. The /admin/agent/ path does not exist in the codebase, causing generated links to point to non-existent pages and creating a mismatch with the URLs emitted by admin tools.

Update the template to use https://nuxt.com/dashboard/chat/${chat-id}.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@server/mcp/prompts/admin/review-agent-chats.ts` at line 22, The chat link in
the admin review prompt uses a non-existent `/admin/agent/` route, so update the
template in review-agent-chats.ts to match the real chat page route used by the
app. Change the generated link text for “Worst sessions” to point to the
dashboard chat path, using the same chat id placeholder, so reports align with
the route handled by the chat page component.

nuxt.config.ts-127-128 (1)

127-128: 🔒 Security & Privacy | 🟡 Minor

Remove unused runtimeConfig.internalApiSecret or align checks to use it.

The internalApiSecret key defined in nuxt.config.ts (line 128) is never consumed via useRuntimeConfig().internalApiSecret anywhere in the codebase. The validation logic in layers/nuxi/agent/lib/internal-api.ts and layers/nuxi/server/utils/internal-api.ts reads process.env.INTERNAL_API_SECRET directly.

This creates a redundant (dead) config entry. If future refactoring assumes this value is available via runtimeConfig, it will default to '' (per line 128), bypassing the strict env check.

Action:

• Option A (Cleanup): Remove internalApiSecret from nuxt.config.ts entirely, as the checks correctly use process.env.
• Option B (Refactor): Update internal-api.ts files to use const secret = useRuntimeConfig().internalApiSecret (and remove the || '' fallback in nuxt.config.ts to force failure on missing env), centralizing config access.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@nuxt.config.ts` around lines 127 - 128, The runtimeConfig entry for
internalApiSecret is redundant because the internal API checks already read
process.env.INTERNAL_API_SECRET directly. Either remove internalApiSecret from
nuxt.config.ts if you want to keep the current env-based validation in
layers/nuxi/agent/lib/internal-api.ts and
layers/nuxi/server/utils/internal-api.ts, or refactor those internal-api helpers
to read useRuntimeConfig().internalApiSecret and drop the fallback so missing
secrets fail consistently.

layers/nuxi/server/api/chats/[id]/state.patch.ts-54-63 (1)

54-63: 🗄️ Data Integrity & Integration | 🟡 Minor

Confirm messages represents the complete history or enforce a full-snapshot contract.

The PATCH handler deletes all existing messages for the chat before inserting body.messages. If the caller passes a partial list, the unlisted messages are permanently lost.

Verification of thread-state.ts confirms the primary caller (createEveFinishHandler) passes the full agentMessages array. However, persistChatState is an exported utility accepting an optional messages array; if invoked elsewhere with a truncated list, data loss will occur.

Additionally, the insert lacks onConflictDoNothing. A payload containing duplicate ids will abort the transaction with a 500 error.

Code context

diff --git a/layers/nuxi/server/api/chats/[id]/state.patch.ts
--- a/layers/nuxi/server/api/chats/[id]/state.patch.ts
+++ b/layers/nuxi/server/api/chats/[id]/state.patch.ts
@@ -54,6 +54,7 @@
     if (body.messages?.length) {
       await tx.delete(schema.messages).where(eq(schema.messages.chatId, id))
       await tx.insert(schema.messages).values(body.messages.map(m => ({
+        // Warning: this deletes all previous messages if body.messages is not a full snapshot
         id: m.id,
         chatId: id,
         role: m.role,

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/server/api/chats/`[id]/state.patch.ts around lines 54 - 63, The
PATCH handler in state.patch.ts currently treats body.messages as a full
replacement but does not enforce that contract, so partial payloads can delete
existing chat history; either validate that the caller always provides the
complete snapshot in persistChatState/createEveFinishHandler or change the
update flow to merge instead of replacing. Also update the schema.messages
insert path to tolerate duplicate message ids by using the existing
tx.insert(schema.messages) flow with conflict handling such as
onConflictDoNothing, so a repeated id does not fail the transaction.

layers/nuxi/server/api/internal/github/search-issues.post.ts-6-10 (1)

6-10: 🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Constrain query to a non-empty string.

query: z.string() accepts an empty string, which forwards a meaningless search to searchGitHubIssues. The sibling web-search endpoint already uses z.string().min(1); align here for consistent input validation.

♻️ Proposed change

   const body = await readValidatedBody(event, z.object({
-    query: z.string(),
+    query: z.string().min(1),
     repo: z.string().optional(),
     state: z.enum(['open', 'closed', 'all']).optional()
   }).parse)

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/server/api/internal/github/search-issues.post.ts` around lines 6
- 10, The request validation in readValidatedBody for search-issues.post.ts
allows an empty query, which can lead to meaningless searches in
searchGitHubIssues. Update the z.object schema used in this handler so the query
field requires a non-empty string, matching the validation pattern used by the
sibling web-search endpoint and keeping input handling consistent.

layers/nuxi/server/api/internal/agent/web-search.post.ts-19-23 (1)

19-23: 🔒 Security & Privacy | 🟡 Minor

Avoid surfacing raw provider error messages.

Returning (error as Error).message directly exposes potential internal provider details and assumes the thrown value is always an Error instance. Instead, log the full error (including the cause chain) server-side and return a generic message to the client.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/server/api/internal/agent/web-search.post.ts` around lines 19 -
23, The web-search error handling in webSearch.post currently returns the raw
provider message to the client and assumes the thrown value is always an Error.
Update the catch block in the web-search handler to log the full error
server-side, including any cause chain, and return a generic client-facing
message instead of using error.message directly.

layers/nuxi/server/utils/internal-api.ts-13-19 (1)

13-19: 🔒 Security & Privacy | 🟡 Minor | ⚡ Quick win

Use a constant-time comparison for the bearer secret.

requireInternalRequest is the central auth gate for every internal endpoint, but the secret is compared with !==, which short-circuits on the first differing byte and is susceptible to timing analysis. Prefer a constant-time comparison.

🔒 Proposed hardening

+import { timingSafeEqual } from 'node:crypto'
 import type { H3Event } from 'h3'

 export function requireInternalRequest(event: H3Event) {
   const secret = process.env.INTERNAL_API_SECRET?.trim()

   if (!secret) {
     throw createError({
       statusCode: 503,
       statusMessage: 'Internal API is not configured'
     })
   }

   const authorization = getRequestHeader(event, 'authorization')
-  if (authorization !== `Bearer ${secret}`) {
+  const expected = `Bearer ${secret}`
+  const provided = authorization ?? ''
+  const a = Buffer.from(provided)
+  const b = Buffer.from(expected)
+  if (a.length !== b.length || !timingSafeEqual(a, b)) {
     throw createError({
       statusCode: 401,
       statusMessage: 'Unauthorized'
     })
   }
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/server/utils/internal-api.ts` around lines 13 - 19, The bearer
secret check in requireInternalRequest currently uses a normal string
comparison, which can leak timing information. Update the authorization
validation in this function to use a constant-time equality check when comparing
the incoming Authorization header against the expected Bearer value, while
preserving the existing 401 Unauthorized behavior for mismatches.

layers/nuxi/agent/tools/show_blog_post.ts-6-10 (1)

6-10: 🎯 Functional Correctness | 🟡 Minor

Reject whitespace-only blog titles.

The title field in inputSchema uses z.string() without trim or minimum-length validation. This allows empty or whitespace-only strings to be sent to /api/internal/content, resulting in invalid or unhelpful API queries. Update the schema to trim input and enforce at least one character.

Snippet

inputSchema: z.object({
  title: z.string().describe('The blog post title or search keyword (e.g., "v4", "Nuxt 3.15", "TypeScript")')
}),

Use .trim().min(1) to ensure valid input:

title: z.string().trim().min(1).describe('...')

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/agent/tools/show_blog_post.ts` around lines 6 - 10, The title
validation in showBlogPost is too permissive because inputSchema accepts empty
or whitespace-only strings. Update the zod schema for title to trim the value
and require at least one character before it is sent to /api/internal/content,
using the existing inputSchema in show_blog_post.ts so the body builder only
receives valid blog search terms.

layers/nuxi/agent/tools/web_search.ts-6-8 (1)

6-8: 🚀 Performance & Scalability | 🟡 Minor

Require a non-empty, trimmed web search query.

The current inputSchema accepts empty or whitespace-only strings via z.string(). This risks triggering meaningless remote search requests and consuming external search budget.

Update the schema to enforce validation:

Proposed change for layers/nuxi/agent/tools/web_search.ts

inputSchema: z.object({
  query: z.string().min(1, 'Search query cannot be empty').trim().describe('Search query — match the user\'s wording; do not add calendar years unless they asked for one')
}),

Add .min(1) to reject empty strings and .trim() to reject whitespace-only inputs.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/agent/tools/web_search.ts` around lines 6 - 8, The web search
tool schema currently accepts empty or whitespace-only queries because the
`inputSchema` in `web_search.ts` only uses `z.string()`. Update the `query`
field validation in `inputSchema` to require a non-empty trimmed string by
adding trimming and a minimum-length check so invalid searches are rejected
before reaching the remote search call.

layers/nuxi/agent/tools/search_github_issues.ts-6-10 (1)

6-10: 🎯 Functional Correctness | 🟡 Minor

Reject blank issue searches.

The query field currently accepts empty strings and whitespace-only input because z.string() has no length constraints. This allows the agent to trigger broad or invalid GitHub searches. Update the schema to enforce a non-empty, trimmed string:

- query: z.string().describe('Error message, keyword, or search term'),
+ query: z.string().trim().min(1, 'Search query cannot be empty').describe('Error message, keyword, or search term'),

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/agent/tools/search_github_issues.ts` around lines 6 - 10, The
search_github_issues tool currently allows blank or whitespace-only queries
because inputSchema uses a plain z.string() for query. Update the query
validator in search_github_issues.ts to require a trimmed, non-empty string so
the tool rejects empty searches before reaching GitHub. Use the inputSchema
definition and its query field as the place to apply the constraint.

layers/nuxi/agent/hooks/chat-title.ts-14-29 (1)

14-29: 🩺 Stability & Availability | 🟡 Minor

Wrap the title fetch to prevent network errors from disrupting message flow.

According to the Eve framework documentation, errors thrown from message.received hooks propagate through the event loop and can escalate to turn.failed or session.failed events. The current implementation only handles non-OK HTTP responses but lacks a try/catch wrapper around the fetch call, meaning transient network failures (DNS issues, connection timeouts, etc.) will disrupt the normal message flow instead of degrading gracefully.

Wrap the entire request block in try/catch to ensure title generation remains best-effort:

Proposed fix

-      const response = await fetch(`${appOrigin()}/api/internal/chats/${encodeURIComponent(chatId)}/title`, {
-        method: 'POST',
-        headers: internalHeaders(),
-        body: JSON.stringify({
-          userId: auth.principalId,
-          message: {
-            role: 'user',
-            parts: [{ type: 'text', text: message }]
-          }
-        })
-      })
-
-      if (!response.ok) {
-        const text = await response.text().catch(() => '')
-        console.warn(`[chat-title] title generation failed (${response.status}): ${text}`)
-      }
+      try {
+        const response = await fetch(`${appOrigin()}/api/internal/chats/${encodeURIComponent(chatId)}/title`, {
+          method: 'POST',
+          headers: internalHeaders(),
+          body: JSON.stringify({
+            userId: auth.principalId,
+            message: {
+              role: 'user',
+              parts: [{ type: 'text', text: message }]
+            }
+          })
+        })
+
+        if (!response.ok) {
+          const text = await response.text().catch(() => '')
+          console.warn(`[chat-title] title generation failed (${response.status}): ${text}`)
+        }
+      } catch (error) {
+        console.warn('[chat-title] title generation request errored', error)
+      }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/agent/hooks/chat-title.ts` around lines 14 - 29, The chat title
request in the `message.received` hook only handles non-OK responses, so network
exceptions from `fetch` can still bubble up and break message flow. Wrap the
entire title-generation block in a `try/catch` in `chat-title.ts`, keeping the
existing `response.ok` handling inside the `try` and logging any thrown error as
a best-effort failure. Use the existing `appOrigin()`, `internalHeaders()`, and
`console.warn` path so the hook degrades gracefully without interrupting the
main message lifecycle.

layers/nuxi/app/composables/useAgentChat.ts-197-212 (1)

197-212: 🗄️ Data Integrity & Integration | 🟡 Minor | ⚡ Quick win

Re-entrancy can double-persist the first user message.

initialDbPersistDone.value = true is set only after the awaited appendUserMessageToChat/createChatWithMessage call. Unlike useStartChat, the chat-mode send/onSubmit path has no loading guard, so two quick submits (or programmatic askQuestion) can both pass the initialDbPersistDone check before either resolves, issuing duplicate persistence calls (and a duplicate POST /api/chats that can error). Set the flag optimistically before awaiting and roll back on failure.

🛡️ Proposed guard-before-await

 async function persistFirstUserMessage(parts: UIMessage['parts']) {
   if (initialDbPersistDone.value) return
+  initialDbPersistDone.value = true

   const metadata = {
     createdAt: new Date().toISOString(),
     ...(useContext.value && agent.currentPage.value ? { pagePath: agent.currentPage.value } : {})
   }

-  if (chatOptions.persistedInDb) {
-    await appendUserMessageToChat(chatOptions.chatId, parts, metadata)
-  } else {
-    await createChatWithMessage(chatOptions.chatId, parts, metadata)
-  }
-
-  initialDbPersistDone.value = true
+  try {
+    if (chatOptions.persistedInDb) {
+      await appendUserMessageToChat(chatOptions.chatId, parts, metadata)
+    } else {
+      await createChatWithMessage(chatOptions.chatId, parts, metadata)
+    }
+  } catch (error) {
+    initialDbPersistDone.value = false
+    throw error
+  }
}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/app/composables/useAgentChat.ts` around lines 197 - 212, The
first-user-message persistence flow in persistFirstUserMessage can run twice
because initialDbPersistDone.value is only set after awaiting
appendUserMessageToChat/createChatWithMessage. Set the flag optimistically
before the await so concurrent send/onSubmit or askQuestion calls in
useAgentChat cannot pass the guard twice, and if the persistence call fails,
roll the flag back so the message can be retried safely.

layers/nuxi/app/composables/useAgentChat.ts-14-19 (1)

14-19: 📐 Maintainability & Code Quality | 🟡 Minor

Add explicit import for ChatEveState type.

ChatEveState is referenced on line 18 but has no explicit import in this file. The type is defined in layers/nuxi/shared/types/chat.ts, which is not in Nuxt's default auto-import paths (composables/, components/, utils/, types/).

Recommended fix:

import type { ChatEveState } from '../../shared/types/chat'

This ensures the type resolves correctly during compilation, regardless of whether custom modules configure auto-imports for the shared/ directory.

Current imports in useAgentChat.ts

import type { UIMessage } from 'ai'
import { buildMessageParts, getMessageTextLength } from '../../shared/utils/paste-attachment'
import { createEveChatSession } from './eve/session'
import { getOrCreateEveAgent } from './eve/init'
import { toUIMessages } from './eve/adapter'
import {
  createEveFinishHandler,
  readAnonymousTitle,
  resumeOptionsFromChat
} from './eve/thread-state'
import { useChatVotes } from './useChatVotes'
import { usePasteAttachment } from './usePasteAttachment'

Note that eve/thread-state.ts properly imports ChatEveState:

import type { ChatEveState, ChatDetail } from '../../../shared/types/chat'

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/app/composables/useAgentChat.ts` around lines 14 - 19,
`useAgentChat.ts` references `ChatEveState` in `ChatModeOptions` without
importing it explicitly, so add a type-only import for `ChatEveState` from the
shared chat types alongside the existing imports. Keep the change localized to
the `useAgentChat` composable and ensure the `ChatModeOptions` definition
resolves the type directly rather than relying on auto-imports.

layers/nuxi/README.md (1)

5-5: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Suppress false-positive markdownlint warning.

The fenced code block at line 5 contains a directory tree diagram, not executable code. Add a language tag (e.g., text) to suppress the MD040 warning.

-```
+```text

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/README.md` at line 5, The README’s fenced directory tree block is
triggering a markdownlint MD040 false positive because it has no language tag.
Update the fenced block in the README to use a non-code label such as text so
the directory tree remains rendered as plain text while suppressing the warning.

layers/nuxi/app/composables/useChatTools.ts (1)

85-95: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Redundant double normalization (non-blocking).

getToolText (Line 210) passes a normalized name into parseToolName, which normalizes again internally (Line 86). It's idempotent so behavior is unaffected; consider normalizing in one place to avoid confusion.

Also applies to: 208-210

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@layers/nuxi/app/composables/useChatTools.ts` around lines 85 - 95,
`getToolText` is normalizing the tool name before calling `parseToolName`, but
`parseToolName` also normalizes internally, causing redundant double
normalization. Update the flow so normalization happens in only one place:
either pass the raw tool name into `parseToolName` and keep its current
behavior, or remove the internal normalization and let `getToolText` own it. Use
the `getToolText` and `parseToolName` symbols to keep the change localized and
consistent.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes